import * as fs from 'fs';
import * as path from 'path';
import { Translation, TranslationInfo } from '../types/translation';
import { ExtractionResult } from '../types';
import { logger } from '../utils/logger';

/**
 * 翻译存储服务
 * 负责统一数据结构并优化存储架构
 */
export class TranslationStore {
  /**
   * 根据项目ID获取报告目录路径
   * @param projectId 项目ID
   * @returns 报告目录路径
   */
  static getReportDirectory(projectId: string): string {
    const reportsBaseDir = path.resolve(process.cwd(), 'reports');
    
    // 确保基本报告目录存在
    if (!fs.existsSync(reportsBaseDir)) {
      logger.info(`创建基础报告目录: ${reportsBaseDir}`);
      fs.mkdirSync(reportsBaseDir, { recursive: true });
    }
    
    const projectDir = path.join(reportsBaseDir, projectId);
    
    // 确保项目报告目录存在
    if (!fs.existsSync(projectDir)) {
      logger.info(`创建项目报告目录: ${projectDir}`);
      fs.mkdirSync(projectDir, { recursive: true });
    }
    
    return projectDir;
  }
  
  /**
   * 保存原始提取结果
   * @param extractionResult 提取结果
   * @param projectId 项目ID
   * @returns 保存的文件路径
   */
  static saveExtractionResult(extractionResult: ExtractionResult, projectId: string): string {
    const timestamp = Date.now();
    const filename = `extraction-result-${timestamp}.json`;
    const projectDir = this.getReportDirectory(projectId);
    const filePath = path.join(projectDir, filename);
    
    // 统一数据结构：将translations改为values
    const normalizedResult = this.normalizeExtractionResult(extractionResult);
    
    // 保存到文件
    fs.writeFileSync(filePath, JSON.stringify(normalizedResult, null, 2), 'utf-8');
    
    return filePath;
  }
  
  /**
   * 保存分类结果
   * @param classificationResult 分类结果
   * @param projectId 项目ID
   * @returns 保存的文件路径
   */
  static saveClassificationResult(classificationResult: any, projectId: string): string {
    const timestamp = Date.now();
    const filename = `classified-result-${timestamp}.json`;
    const projectDir = this.getReportDirectory(projectId);
    const filePath = path.join(projectDir, filename);
    
    // 保存到文件
    fs.writeFileSync(filePath, JSON.stringify(classificationResult, null, 2), 'utf-8');
    
    return filePath;
  }
  
  /**
   * 保存模块树结果
   * @param moduleTree 模块树结果
   * @param statistics 统计信息
   * @param projectId 项目ID
   * @returns 保存的文件路径
   */
  static saveModuleTree(moduleTree: any, statistics: any, projectId: string): string {
    const timestamp = Date.now();
    const filename = `module-tree-${timestamp}.json`;
    const projectDir = this.getReportDirectory(projectId);
    const filePath = path.join(projectDir, filename);
    
    // 保存到文件
    fs.writeFileSync(filePath, JSON.stringify({
      moduleTree,
      statistics
    }, null, 2), 'utf-8');
    
    return filePath;
  }
  
  /**
   * 保存模块化报告
   * @param report 报告内容
   * @param projectId 项目ID
   * @returns 保存的文件路径
   */
  static saveModuleReport(report: string, projectId: string): string {
    const timestamp = Date.now();
    const filename = `module-report-${timestamp}.txt`;
    const projectDir = this.getReportDirectory(projectId);
    const filePath = path.join(projectDir, filename);
    
    // 保存到文件
    fs.writeFileSync(filePath, report, 'utf-8');
    
    return filePath;
  }
  
  /**
   * 标准化提取结果（将translations改为values）
   * @param extractionResult 原始提取结果
   * @returns 标准化后的提取结果
   */
  private static normalizeExtractionResult(extractionResult: ExtractionResult): any {
    const result = { ...extractionResult };
    
    // 转换translations数组
    if (result.translations && Array.isArray(result.translations)) {
      result.translations = result.translations.map((translation: any) => {
        // 检查是否为TranslationInfo类型对象（有values属性）
        if (translation.values && Array.isArray(translation.values)) {
          return translation; // 已经是标准格式，不需要转换
        }
        
        // 对于老格式的对象（有translations属性）
        if (translation.translations && Array.isArray(translation.translations)) {
          // 创建新对象，不修改原对象
          const normalized = { ...translation };
          normalized.values = translation.translations;
          delete normalized.translations;
          return normalized;
        }
        
        return translation;
      });
    }
    
    return result;
  }
} 